﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Windows.Forms;
using System.Xml.Linq;
using Growatt.OSC.Util;
using Growatt.WaveData.DataSetResolve;
using Newtonsoft.Json; // 引入 JSON 序列化库

namespace LEDVANCE.Oscilloscope.VirtualOscilloscope.DataGridViewHelper
{
    public class DatagirdViewHelper
    {
        // 静态变量
        public static BindingList<ModelSaveString> modelList = new BindingList<ModelSaveString>();
        public static BindingSource bindingSource = new BindingSource();
        public static DataTable originalDataTable = new DataTable();
        public static List<ModelSaveString> selectedModels = new List<ModelSaveString>();

        // 委托
        public delegate List<ModelSaveString> GetModelDelegate();
        public delegate void AddModelDelegate(ModelSaveString model);
        public delegate void DeleteModelDelegate(ModelSaveString model);
        public delegate void SearchModelDelegate(string txt);
        public delegate void DeleteAllModelsDelegate();

        // 委托实例
        public AddModelDelegate AddModel { get; set; }
        public DeleteModelDelegate DeleteModel { get; set; }
        public DeleteAllModelsDelegate DeleteAllModels { get; set; }
        public SearchModelDelegate SearchModels { get; set; }
        public GetModelDelegate GetModels { get; set; }

        public DataGridView DataGridView = null;

        // JSON 文件路径
        private string JSONFilePath = "data.json";

        public DatagirdViewHelper(DataGridView DataGridView)
        {
            this.DataGridView = DataGridView;
            // 初始化原始数据并备份
            InitializeData(DataGridView);
            // 初始化委托
            AddModel = AddModelInternal;
            DeleteModel = DeleteModelInternal;
            DeleteAllModels = DeleteAllModelsInternal;
            SearchModels = textBoxFilter_TextChanged;
            // 初始化选中的行列表
            selectedModels = new List<ModelSaveString>();
            // 添加右击事件处理程序
            DataGridView.MouseDown += dataGridView_MouseDown;
            // 加载初始数据到 DataGridView
            LoadInitialData();
        }

        #region 静态初始化方法

        // 加载初始数据到模型
        private void LoadInitialData()
        {
            JSONFilePath = Path.Combine(
                $"{Environment.CurrentDirectory}\\Parser",
                "ModelSaveString.ini"
            );
            // 从 JSON 文件加载数据
            LoadDataFromJSON(JSONFilePath);
        }

     
        #endregion

        #region JSON 文件操作

        // 将 modelList 内容保存到 JSON 文件
        private void SaveDataToJSON(string filePath)
        {
            try
            {
                // 将 modelList 序列化为 JSON 字符串
                string json = JsonConvert.SerializeObject(modelList, Formatting.Indented);

                // 将 JSON 字符串写入文件
                File.WriteAllText(filePath, json);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error saving data to JSON: {ex.Message}");
            }
        }

        // 从 JSON 文件加载数据到 modelList
        private void LoadDataFromJSON(string filePath)
        {
            try
            {
                //// 检查文件是否存在
                //if (File.Exists(filePath))
                //{
                //    // 从文件中读取 JSON 字符串
                //    string json = File.ReadAllText(filePath);

                //    // 将 JSON 字符串反序列化为 BindingList<ModelSaveString>
                //    modelList = JsonConvert.DeserializeObject<BindingList<ModelSaveString>>(json);

                //    // 如果 modelList 为空，初始化为空列表
                //    if (modelList == null)
                //    {
                //        modelList = new BindingList<ModelSaveString>();
                //    }

                //    // 将数据绑定到 DataGridView
                //    bindingSource.DataSource = modelList;
                //    DataGridView.DataSource = bindingSource;
                //}
                //else
                //{
                //    // 如果文件不存在，初始化为空列表
                //    modelList = new BindingList<ModelSaveString>();
                //    bindingSource.DataSource = modelList;
                //    DataGridView.DataSource = bindingSource;
                //}
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error loading data from JSON: {ex.Message}");
            }
        }

        private BindingList<ModelSaveString> LoadDataFromJSON2(string filePath)
        {
            try
            {
                // 检查文件是否存在
                if (File.Exists(filePath))
                {
                    // 从文件中读取 JSON 字符串
                    string json = File.ReadAllText(filePath);

                    // 将 JSON 字符串反序列化为 BindingList<ModelSaveString>
                    var modelList = JsonConvert.DeserializeObject<BindingList<ModelSaveString>>(json);

                    // 如果 modelList 为空，初始化为空列表
                    if (modelList == null)
                    {
                        modelList = new BindingList<ModelSaveString>();
                    }
                    return modelList;
                }
                return null;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error loading data from JSON: {ex.Message}");
            }
            return null;
        }

        // 定期保存数据到 JSON 文件
        private void StartAutoSaveTimer()
        {

        }

        #endregion

        #region 数据操作方法

        // 内部方法，供委托调用 - 添加模型
        // 内部方法，供委托调用
        private void AddModelInternal(ModelSaveString model)
        {
            // 检查 Name 是否已经存在
            var existingItem = modelList.FirstOrDefault(item => item.Name == model.Name);
            if (existingItem != null)
            {
                // 更新现有项的内容
                existingItem.Name = model.Name;
                existingItem.Type = model.Type;
                existingItem.Scale = model.Scale;
                existingItem.Address = model.Address;
                //existingItem.SignalOffset = model.SignalOffset;
                existingItem.IsSelected = model.IsSelected;

                // 找到 existingItem 在 modelList 中的索引
                int existingIndex = modelList.IndexOf(existingItem);

                // 如果 existingItem 不在第一行，将其移动到最前面一行
                if (existingIndex != 0)
                {
                    modelList.RemoveAt(existingIndex);
                    modelList.Insert(0, existingItem);
                }

                // 更新 originalDataTable 中相应行的内容
                DataRow[] rowsToUpdate = originalDataTable.Select($"Name = '{model.Name}'");
                foreach (DataRow row in rowsToUpdate)
                {
                    row["Name"] = model.Name;
                    row["Type"] = model.Type;
                    row["Scale"] = model.Scale;
                    row["Address"] = model.Address;
                    row["SignalOffset"] = model.SignalOffset;
                    row["IsSelected"] = model.IsSelected;

                    // 如果行不是第一行，则将其移动到第一行
                    if (row.Table.Rows.IndexOf(row) != 0)
                    {
                        originalDataTable.Rows.Remove(row);
                        originalDataTable.Rows.InsertAt(row, 0);
                    }
                }

                // 重置 bindingSource 以反映更改
                bindingSource.ResetBindings(false);
            }
            else
            {
                // 添加到 modelList 和 originalDataTable 的第一行
                modelList.Insert(0, model); // 确保插入到第一行
                                            // 创建一个新的 DataRow 并插入到 originalDataTable 的第一行
                DataRow newRow = originalDataTable.NewRow();
                newRow["Name"] = model.Name;
                newRow["Type"] = model.Type;
                newRow["Scale"] = model.Scale;
                newRow["Address"] = model.Address;
                newRow["SignalOffset"] = model.SignalOffset;
                newRow["IsSelected"] = model.IsSelected;
                originalDataTable.Rows.InsertAt(newRow, 0); // 确保插入到第一行
                                                            // 重置 bindingSource 以反映更改
                bindingSource.ResetBindings(false);
            }
            SaveDataToJSON(JSONFilePath);
        }

        // 内部方法，供委托调用 - 删除模型
        private void DeleteModelInternal(ModelSaveString modelToDelete)
        {
            // 检查 modelToDelete 是否为 null
            if (modelToDelete == null)
            {
                Console.WriteLine("Model to delete is null.");
                return;
            }

            // 查找要删除的模型在 modelList 中的索引
            int index = modelList.IndexOf(modelToDelete);

            // 如果找到了要删除的模型
            if (index >= 0)
            {
                // 从 modelList 中移除该项
                modelList.RemoveAt(index);

                // 从 originalDataTable 中移除相应的行
                DataRow[] rowsToDelete = originalDataTable.Select($"Name = '{modelToDelete.Name}'");
                foreach (DataRow row in rowsToDelete)
                {
                    originalDataTable.Rows.Remove(row);
                }

                // 清空选中的行列表
                selectedModels.Clear();

                // 重置 bindingSource 以反映更改
                bindingSource.ResetBindings(false);

                // 将更新后的 modelList 同步到 JSON 文件
                SaveDataToJSON(JSONFilePath);
            }
            else
            {
                Console.WriteLine("Model not found in the list.");
            }
        }

        // 内部方法，供委托调用 - 删除所有模型
        private void DeleteAllModelsInternal()
        {
            // 清空 modelList
            modelList.Clear();

            // 清空 originalDataTable
            originalDataTable.Clear();

            // 清空选中的行列表
            selectedModels.Clear();

            // 重置 bindingSource 以反映更改
            bindingSource.ResetBindings(false);

            // 将更新后的 modelList 同步到 JSON 文件
            SaveDataToJSON(JSONFilePath);
        }

        // 获取选中的模型
        private List<ModelSaveString> GetSelectedModels()
        {
            return selectedModels;
        }

        #endregion

        #region DataGridView 相关方法

        // 初始化 DataGridView
        private void InitializeData(DataGridView DataGridView)
        {
            DataGridView = DataGridView;

            // 创建一个 DataTable 来存储原始数据
            originalDataTable = new DataTable();
            originalDataTable.Columns.Add("Name", typeof(string));
            originalDataTable.Columns.Add("Type", typeof(string));
            originalDataTable.Columns.Add("Scale", typeof(string));
            originalDataTable.Columns.Add("Address", typeof(string));
            originalDataTable.Columns.Add("SignalOffset", typeof(string));
            originalDataTable.Columns.Add("IsSelected", typeof(bool));

            // 将 ModelSaveString 列表转换为 DataTable
            foreach (var item in modelList)
            {
                originalDataTable.Rows.Add(
                    item.Name,
                    item.Type,
                    item.Scale,
                    item.Address,
                    item.SignalOffset,
                    item.IsSelected
                );
            }

            // 配置 DataGridView
            DataGridView.AllowDrop = true;
            DataGridView.SelectionMode = DataGridViewSelectionMode.FullRowSelect;
            DataGridView.AllowUserToAddRows = false;
            DataGridView.AllowUserToDeleteRows = false;

            // 创建 BindingSource 并绑定到 BindingList
            bindingSource = new BindingSource();
            bindingSource.DataSource = modelList;
            DataGridView.DataSource = bindingSource;

            // 添加事件处理
            DataGridView.DragOver += dataGridView_DragOver;
            DataGridView.DragDrop += dataGridView_DragDrop;
            DataGridView.DragEnter += dataGridView_DragEnter;

            // 允许编辑 IsSelected 列
        }

        // 设置 DataGridView 可编辑

        // 右击事件处理
        private void dataGridView_MouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                int rowIndex = DataGridView.HitTest(e.X, e.Y).RowIndex;
                if (rowIndex >= 0 && rowIndex < DataGridView.Rows.Count)
                {
                    // 选中右击的行
                    DataGridView.ClearSelection();
                    DataGridView.Rows[rowIndex].Selected = true;

                    if (DataGridView.SelectedRows.Count > 0)
                    {
                        var modelToDelete = (ModelSaveString)
                            DataGridView.SelectedRows[0].DataBoundItem;
                        DeleteModel(modelToDelete);
                    }
                }
            }
            else if (e.Button == MouseButtons.Left)
            {
                int rowIndex = DataGridView.HitTest(e.X, e.Y).RowIndex;
                if (rowIndex >= 0 && rowIndex < DataGridView.Rows.Count)
                {
                    // 确保拖动的不是新行
                    if (!DataGridView.Rows[rowIndex].IsNewRow)
                    {
                        // 开始拖放操作
                        DataGridView.DoDragDrop(DataGridView.Rows[rowIndex], DragDropEffects.Move);
                    }
                }
            }
        }

        // 拖放事件处理
        private void dataGridView_DragEnter(object sender, DragEventArgs e)
        {
            // 验证拖放的数据格式
            if (e.Data.GetDataPresent(typeof(DataGridViewRow)))
            {
                e.Effect = DragDropEffects.Move;
            }
            else
            {
                e.Effect = DragDropEffects.None;
            }
        }

        private void dataGridView_DragOver(object sender, DragEventArgs e)
        {
            // 确保拖放操作是有效的
            if (e.Data.GetDataPresent(typeof(DataGridViewRow)))
            {
                e.Effect = DragDropEffects.Move;
            }
            else
            {
                e.Effect = DragDropEffects.None;
            }
        }

        private void dataGridView_DragDrop(object sender, DragEventArgs e)
        {
            try
            {
                // 确保数据源已初始化
                if (bindingSource == null || modelList == null)
                {
                    throw new InvalidOperationException("Data sources are not initialized.");
                }

                // 获取拖放的行
                DataGridViewRow dragRow = (DataGridViewRow)e.Data.GetData(typeof(DataGridViewRow));

                // 获取鼠标位置对应的行索引
                int targetIndex = DataGridView
                    .HitTest(
                        DataGridView.PointToClient(new Point(e.X, e.Y)).X,
                        DataGridView.PointToClient(new Point(e.X, e.Y)).Y
                    )
                    .RowIndex;

                if (targetIndex >= 0 && dragRow != null)
                {
                    // 获取拖放的行在数据源中的索引
                    int sourceIndex = DataGridView.Rows.IndexOf(dragRow);
                    if (sourceIndex < 0)
                        return;

                    // 从原始位置移除行
                    ModelSaveString draggedItem = modelList[sourceIndex];
                    modelList.RemoveAt(sourceIndex);

                    // 在目标位置插入行
                    modelList.Insert(targetIndex, draggedItem);

                    // 确保 DataGridView 显示正确的数据
                    DataGridView.DataSource = null;
                    DataGridView.DataSource = bindingSource;

                    // 选中移动后的行
                    DataGridView.Rows[targetIndex].Selected = true;

                    // 重置 bindingSource 以反映更改
                    bindingSource.ResetBindings(false);

                    Console.WriteLine(string.Join(",", modelList.Select(item => item.Name)));

                    // 将更新后的 modelList 同步到 JSON 文件
                    SaveDataToJSON(JSONFilePath);
                }
            }
            catch (Exception ex)
            {
                // 记录异常信息
                Console.WriteLine($"Error during drag and drop: {ex.Message}");
            }
        }

        // 单元格值改变事件


        private void textBoxFilter_TextChanged(string searchText)
        {
            try
            {
                string filterText = searchText.ToLower();
                // 清空当前的 modelList
                modelList.Clear();
                var datals = LoadDataFromJSON2(JSONFilePath);
                //找到
                foreach (ModelSaveString item in datals)
                { //条件查找 不区分大小写
                    if (item.Name.IndexOf(filterText) > -1)
                    {
                        modelList.Add(item);
                    }
                }
                // 重置 bindingSource 以反映更改
                bindingSource.ResetBindings(false);
                Debug.WriteLine($"Loaded {modelList.Count} items from JSON.");
            }
            catch (Exception ex)
            {
                // 捕获异常并打印错误信息
                Console.WriteLine($"Error: {ex.Message}");
            }
        }

        #endregion
    }
}
